ReadNCFile2 avec Token Modificateur
Le CNC12_TokenModifier.project
un exemple de projet se trouve dans le répertoire d'installation de CODESYS sous ..\CODESYS SoftMotion\Examples
.
Cet exemple montre comment modifier le code G lors de l'importation afin de convertir l'unité de vitesse de trajectoire (mot F) de mm/min en mm/s. Pour ce faire, insérez le code G 1/60.0 *
avant la valeur de vitesse pendant la lecture du code G du mot F. F6000
devient alors F 1/60.0 * 6000
, qui est ensuite traitée par le SMC_NCInterpreter
bloc de fonctions pour F100
. Dans les cas simples, vous pouvez ignorer la multiplication par 1/60
et ajustez simplement la valeur (par exemple, à partir de 6000
à 100
). Cependant, la multiplication est plus générale car elle fonctionne également lorsque des variables sont utilisées. F $SPEED$
devient F 1/60.0 * $SPEED$
.
Structure de la demande
Comme d'habitude pour les applications CNC, l'application consiste en un traitement de trajectoire (CNC_PreparePath
programme) et interpolation (CNC
programme). Comme l'interpolation n'est pas différente des autres exemples, elle ne sera pas abordée plus
Le traitement des chemins est appelé cycliquement toutes les 20 ms en basse priorité PathTask
. L'interpolation est appelée cycliquement toutes les 4 ms MotionTask
. La tâche d'arrière-plan VISU_TASK
est défini pour la visualisation.
Vous pouvez commencer à traiter le code G dans la visualisation. Le code G et le mouvement de la machine (portique 3D) sont affichés sur le côté droit de la visualisation
Le code G
CNC_PathSpeed
N10 G01 X1000 F6000 N20 Y1000
Dans ce code G, la vitesse de trajet en bloc N10
est défini avec F6000
jusqu'à 6000 mm/min. Cependant, les blocs fonctionnels CNC s'attendent à une vitesse de trajectoire en mm/s. Deux mouvements linéaires sont commandés, le premier X=1000
puis à X=1000, Y=1000
.
Traitement des jetons
Le SMC_ReadNCFile2
et SMC_ReadNCFromStream
les blocs de fonctions permettent d'effectuer vos propres transformations lorsque le code G est lu. Ici, nous utilisons avec le SMC_ITokenModifier
interface, qui est transmise via aTokenModifier
entrée.
Cette interface fonctionne sur des « jetons ». Il s'agit des éléments de base du code G dans lesquels le texte du code G est subdivisé au démarrage du traitement
N50 G36 O$plc_variable$ D'TextTest' X-1 (Comment)
Ce code G est subdivisé comme suit :
Texte | SMC_TOKENTYPE | SMC_TOKENVALUE |
---|---|---|
| identifer | stValue = 'N' |
| number | fValue = 50.0 |
| identifer | stValue = 'G' |
| number | fValue = 36.0 |
| identifer | stValue = 'O' |
| variable | stValue = 'plc_variable' |
| identifer | stValue = 'D' |
| strLiteral | stValue = 'TextTest' |
| identifer | stValue = 'X' |
| operator | stValue = '-' |
| number | fValue = 1.0 |
Les informations qui ne sont pas nécessaires pour un traitement ultérieur (par exemple, les caractères d'espacement, les sauts de ligne et les commentaires) n'apparaissent pas dans la liste des jetons.
Quand le SMC_ITokenModifier
l'interface est implémentée, la liste des jetons peut être adaptée en ajoutant de nouveaux jetons, en supprimant des jetons et en modifiant les valeurs des jetons.
Start
: Initialisation du bloc fonctionnel. L'état interne est réinitialisé.Call
: appel de cette méthode pendant le traitement du code G. Les jetons peuvent être lus et supprimés de la file d'entrée et ajoutés à la file d'attente de sortie.
Mise en œuvre
Tous les jetons sont déplacés de la file d'entrée vers la file d'attente de sortie.
Si un mot F est détecté, deux nouveaux jetons,
1/60
et*
, sont ajoutés après le jeton pour « F » et avant le jeton pour la valeur de vitesse.
Le Call
La méthode contient la logique pour traiter les jetons. Il est utile de déplacer d'abord les jetons de la file d'entrée (tokensIn
) vers une file d'attente temporaire (m_tmpQueue
), traitez-les là-bas, puis déplacez-les vers la file de sortie (tokensOut
). La file d'attente temporaire n'est pas absolument nécessaire pour adapter la vitesse du trajet, mais elle simplifie la structure du programme dans les cas les plus complexes.
Méthode : Appel
Dans un premier temps, le système attend STATE_RUNNING
état jusqu'à ce que le traitement puisse démarrer (lorsque des jetons sont disponibles dans la file d'entrée et qu'il reste de la place dans la file d'attente de sortie).
IF NOT SMC_NC_CanProcessTokens(tokensIn, tokensOut) THEN // Wait until processing can proceed RETURN; END_IF
Ensuite, un jeton est déplacé de la file d'entrée vers la file d'attente temporaire.
IF m_tmpQueue.IsEmpty() THEN // Move the next token from the in-queue to the tmp-queue. pt := tokensIn.GetFromStart(0); m_tmpQueue.Append(pt^); tokensIn.RemoveFirst(); END_IF
Le traitement proprement dit est effectué dans ConvertSpeed
méthode.
IF NOT m_tmpQueue.IsEmpty() THEN // The actual processing is done here ConvertSpeed(); END_IF
À la fin de la méthode, un jeton est déplacé de la file d'attente temporaire vers la file d'attente de sortie.
Méthode : ConvertSpeed
Le premier jeton de la file d'attente temporaire est vérifié.
Si un identifiant avec la valeur F
est trouvé, puis deux jetons supplémentaires sont ajoutés : le nombre 1/60.0
et l'opérateur *
.
(La taille de la file d'attente temporaire est sélectionnée de telle sorte que deux jetons supplémentaires entrent dans la file d'attente en plus du jeton de la file d'entrée).
tk := m_tmpQueue.GetFromStart(0)^; IF tk.tokenType = SMC_TokenType.identifier THEN tk.GetString(pbyString => pby, iSize => iSize); // 70 = ASCII code for F (path velocity) IF iSize = 1 AND pby^ = 70 THEN // Insert the number 1/60 SMC_Token_InitNumber( tk:= tkNumber, value:= 1/60.0, srcPos:= tk.srcPos); m_tmpQueue.Append(tkNumber); // Insert operator '*' for multiplication SMC_Token_InitOperator( tk:= tkOperator, value:= '*', srcPos:= tk.srcPos); m_tmpQueue.Append(tkOperator); END_IF END_IF
Mise en service
Créez l'application et téléchargez-la sur une manette.
Démarrez l'application, passez à la visualisation et appuyez sur
Start
.